const dgram = require('dgram');

class UdpServer {

  constructor(port = 41234) {
    this.server = null;
    this.host = null;
    this.port = port;
    this.listeners = {}; // 存储自定义事件监听器
    this.sessions = [];  // 存储会话信息
  }


  registry(port, host = ''){
    forEach(this.sessions, (session) => {
      if (session.port === port && session.host === host) {
        console.warn(`会话 ${host}:${port} 已存在`);
        return;
      }
    });
    this.sessions.push({ port, host });
    console.log(`会话 ${host}:${port} 已注册`);
  }

  unregistry(port, host = ''){
    this.sessions = this.sessions.filter(session => !(session.port === port && session.host === host));
    console.log(`会话 ${host}:${port} 已注销`);
  }

  /**
   * 启动 UDP 服务器
   * @param {number} port 监听端口
   * @param {string} host 监听地址（默认 '0.0.0.0'）
   * @returns {Promise} 启动结果
   */
  start(port, host = '0.0.0.0') {
    return new Promise((resolve, reject) => {
      if (this.server) {
        reject(new Error('UDP 服务器已启动'));
        return;
      }

      this.port = port;
      this.host = host;
      this.server = dgram.createSocket({ type: 'udp4', reuseAddr: true });

      this.server.on("connect", () => {
        this.emit('connect', {
          data: msg.toString(),
          client: { ip: rinfo.address, port: rinfo.port }
        });
      });

      // 监听数据接收事件
      this.server.on('message', (msg, rinfo) => {
        this.emit('message', {
          data: msg.toString(),
          client: { ip: rinfo.address, port: rinfo.port }
        });
      });

      // 监听错误事件
      this.server.on('error', (err) => {
        this.emit('error', err);
        this.close(); // 出错时自动关闭
      });

      // 监听关闭事件
      this.server.on('close', () => {
        this.emit('close');
        this.server = null;
      });

      // 绑定端口
      this.server.bind(port, host, (err) => {
        if (err) {
          reject(err);
        } else {
          console.log(`UDP 服务器启动成功，监听 ${host}:${port}`);
          resolve();
        }
      });
    });
  }

  close() {
    return new Promise((resolve) => {
      if (!this.server) {
        resolve();
        return;
      }

      this.server.close(() => {
        console.log('UDP 服务器已关闭');
        this.server = null;
        resolve();
      });
    });
  }

  /**
   * 发送 UDP 数据
   * @param {string|Buffer} data 待发送数据
   * @param {number} port 目标端口
   * @param {string} host 目标地址
   * @returns {Promise} 发送结果
   */
  send(data, port, host) {
    return new Promise((resolve, reject) => {
      if (!this.server) {
        reject(new Error('UDP 服务器未启动'));
        return;
      }

      const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
      this.server.send(buffer, port, host, (err) => {
        if (err) {
          reject(err);
        } else {
          resolve();
        }
      });
    });
  }

  broadcast(data){
    return new Promise((resolve, reject) => {
      if (!this.server) {
        reject(new Error('UDP 服务器未启动'));
        return;
      }

      const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
      this.sessions.forEach(session => {
        this.server.send(buffer, session.port, session.host, (err) => {
          if (err) {
            console.error(`发送到 ${session.host}:${session.port} 失败:`, err);
          } else {
            console.log(`已发送到 ${session.host}:${session.port}`);
          }
        });
      });
      resolve();
    });
  }

  /**
   * 注册事件监听器（如 'message', 'error', 'close'）
   * @param {string} event 事件名称
   * @param {Function} callback 回调函数
   */
  on(event, callback) {
    if (!this.listeners[event]) {
      this.listeners[event] = [];
    }
    this.listeners[event].push(callback);
  }

  /**
   * 触发事件（内部使用）
   * @param {string} event 事件名称
   * @param {*} data 事件数据
   */
  emit(event, data) {
    if (this.listeners[event]) {
      this.listeners[event].forEach(callback => callback(data));
    }
  }

}

module.exports = new UdpServer(); // 导出单例实例
